This time it's a nested IF statement. I don't like too much nested if statements. And I don't like them more if they are this simple and could be better readable with a simple rewrite...

const isChannelMember = async (user_id, channel_id, subserver_id, channelData) => {
    const checkUserPresence = await ChannelUserModel.findOne({ user_id: user_id, channel_id: channel_id });
    if (!checkUserPresence) {
        if (!channelData?.is_public) {
            const roleBaseChannel = await RoleChannelMapModel.find({ channel_id: channel_id }, 'role_id')
            if (roleBaseChannel) {
                const roleids = roleBaseChannel.map(channel => channel.role_id)
                const foundUserForRole = await PermissionModel.find({
                    owner_type: 'user_role',
                    owner_id: user_id,
                    subserver_id: subserver_id,
                    permission_type: 'role',
                    permission_value: { $in: roleids }
                })

                if (!foundUserForRole) {
                    return false
                } else {
                    return true
                }

            }
            else {
                return false
            }
        }
        else {
            return false
        }
    } else {
        return true
    }
}

You see how ugly that code block is? Let's rewrite the block one by one and start with the first condition. It's checking if the user is allowed to access the channel by userID.

First line should kept as is and the first condition can be changed as;

const checkUserPresence = await ChannelUserModel.findOne({ user_id: user_id, channel_id: channel_id });
if (checkUserPresence) return true; 

Now we reduced one nesting. Next step is channelData.is_public condition.

 if (!channelData || channelData.is_public) return false; 

The above line reduces one more indentation. What we are esentially doing in the original code is if it's not null and is_public is false then we do role checking. Otherwise we return false. So we get that otherwise as a condition. if channelData is null/undefined or is_public is true we return false.

Now with the roleBasedChannel condition we can do a guard clause check. If it's null/undefined let's just return false.

const roleBaseChannel = await RoleChannelMapModel.find({ channel_id: channel_id }, 'role_id') // if there're roles assigned to this channel
if (!roleBaseChannel) return false; 

So we are left with last condition. It's also quite easy. We must make it a boolean first then return it. Simply return !!foundUserForRole; should do the trick.

const isChannelMemberReadable = async (user_id, channel_id, subserver_id, channelData) => {
    const checkUserPresence = await ChannelUserModel.findOne({ user_id: user_id, channel_id: channel_id });

    if (checkUserPresence) return true;         
    if (!channelData || channelData.is_public) return false;

    const roleBaseChannel = await RoleChannelMapModel.find({ channel_id: channel_id }, 'role_id') // if there're roles assigned to this channel
    if (!roleBaseChannel) return false; 

    const roleids = roleBaseChannel.map(channel => channel.role_id)
    const foundUserForRole = await PermissionModel.find({
        owner_type: 'user_role',
        owner_id: user_id,
        subserver_id: subserver_id,
        permission_type: 'role',
        permission_value: { $in: roleids }
    });

    return !!foundUserForRole;
}

See? No nesting. Simpler. Easier to track blocks. Also there's a problem here. The roleBaseChannel is an array. Mongoose will return an array and it'll never be null. So checking .length is a better option.